package com.sort;

import javax.xml.crypto.Data;
import java.sql.Array;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.logging.SimpleFormatter;

/**
 * 冒泡排序
 * DuanXS
 */
public class BubbleSort {
    public static void main(String[] args) {
/*        //确定数组
        int arr[] = {3,9,-1,10,-2};

        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));*/

        //测试一下冒泡的速度O(n^2),给八万个数据，测试
        //创建要给80000个的随机数组
        int[] arr =new int[80000];
        for (int i = 0; i < 80000; i++) {
            //生成一个[0，80000]数
            arr[i] = (int)(Math.random()*80000);
        }
        //测试这个数组是否是随机的
       // System.out.println(Arrays.toString(arr));

        //测试排序前的时间
        Date date1 = new Date();
        //输出时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-mm-dd HH:mm:ss");
        //有了这些我们可以拿到一个字符串
        String deta = simpleDateFormat.format(date1);
        System.out.println("排序前的时间"+deta);

        //测试冒泡排序
        bubbleSort(arr);
        //测试排序后的时间
        Date date2 = new Date();
        //有了这些我们可以拿到一个字符串
        String deta2 = simpleDateFormat.format(date2);
        System.out.println("排序后的时间"+deta2);

        /*System.out.println("排序后");
        System.out.println(Arrays.toString(arr));*/

        //为了容器理解，我们把冒泡排序的演变过程，给大家展示出来
        //第一趟就是把最大的数组排在最后
            //临时变量
        int temp = 0;
            //标识变量，表示是否进行过交换
        boolean flag = false;
      /*  for (int j = 0; j < arr.length-1; j++){
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j + 1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第一趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        //第二趟排序，就是将第二大的数排在倒数第二位
        for (int j = 0; j < arr.length-1-1; j++){
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第二趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        //第三趟排序，就是将第三大的数排在倒数第三位
        for (int j = 0; j<arr.length-1-2; j++){
            //如果卡面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第三趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        //第四趟排序，就是将第四大的数排在倒数第四位
        for (int j = 0; j<arr.length-1-3; j++){
            //如果卡面的数比后面的数大，则交换
            if (arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第四趟排序后的数组");
        System.out.println(Arrays.toString(arr));*/


      /*  //找到规律 简化代码
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j<arr.length-1-i; j++){
                //如果卡面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"趟排序后的数组");
            System.out.println(Arrays.toString(arr));

            //在一趟排序中，一次交换都没有发生过
            if (!flag){
                break;
            }else {
                //重置flag，进行下次判断
                flag = false;
            }
        }*/
    }
    //将前面的冒泡排序算法，封装成一个方法
    public static void bubbleSort(int[] arr){

        //为了容器理解，我们把冒泡排序的演变过程，给大家展示出来
        //第一趟就是把最大的数组排在最后
        //临时变量
        int temp = 0;
        //标识变量，表示是否进行过交换
        boolean flag = false;
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j<arr.length-1-i; j++){
                //如果卡面的数比后面的数大，则交换
                if (arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            //System.out.println("第"+(i+1)+"趟排序后的数组");
            //System.out.println(Arrays.toString(arr));

            //在一趟排序中，一次交换都没有发生过
            if (!flag){
                break;
            }else {
                //重置flag，进行下次判断
                flag = false;
            }
        }

    }
}
